/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package controladores;

import controladores.exceptions.IllegalOrphanException;
import controladores.exceptions.NonexistentEntityException;
import controladores.exceptions.PreexistingEntityException;
import entidades.Proyecto;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import entidades.Unidadorganizacional;
import java.util.ArrayList;
import java.util.List;
import entidades.Comite;
import entidades.Etapa;
import entidades.Rubros;
import entidades.Provedor;
import entidades.Recursos;
import entidades.Convenios;
import entidades.Insumo;

/**
 *
 * @author Andres
 */
public class ProyectoJpaController {

    public ProyectoJpaController() {
        emf = Persistence.createEntityManagerFactory("proyectoCongresoPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Proyecto proyecto) throws PreexistingEntityException, Exception {
        if (proyecto.getUnidadorganizacionalList() == null) {
            proyecto.setUnidadorganizacionalList(new ArrayList<Unidadorganizacional>());
        }
        if (proyecto.getComiteList() == null) {
            proyecto.setComiteList(new ArrayList<Comite>());
        }
        if (proyecto.getEtapaList() == null) {
            proyecto.setEtapaList(new ArrayList<Etapa>());
        }
        if (proyecto.getRubrosList() == null) {
            proyecto.setRubrosList(new ArrayList<Rubros>());
        }
        if (proyecto.getProvedorList() == null) {
            proyecto.setProvedorList(new ArrayList<Provedor>());
        }
        if (proyecto.getRecursosList() == null) {
            proyecto.setRecursosList(new ArrayList<Recursos>());
        }
        if (proyecto.getConveniosList() == null) {
            proyecto.setConveniosList(new ArrayList<Convenios>());
        }
        if (proyecto.getInsumoList() == null) {
            proyecto.setInsumoList(new ArrayList<Insumo>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            List<Unidadorganizacional> attachedUnidadorganizacionalList = new ArrayList<Unidadorganizacional>();
            for (Unidadorganizacional unidadorganizacionalListUnidadorganizacionalToAttach : proyecto.getUnidadorganizacionalList()) {
                unidadorganizacionalListUnidadorganizacionalToAttach = em.getReference(unidadorganizacionalListUnidadorganizacionalToAttach.getClass(), unidadorganizacionalListUnidadorganizacionalToAttach.getCodigounidad());
                attachedUnidadorganizacionalList.add(unidadorganizacionalListUnidadorganizacionalToAttach);
            }
            proyecto.setUnidadorganizacionalList(attachedUnidadorganizacionalList);
            List<Comite> attachedComiteList = new ArrayList<Comite>();
            for (Comite comiteListComiteToAttach : proyecto.getComiteList()) {
                comiteListComiteToAttach = em.getReference(comiteListComiteToAttach.getClass(), comiteListComiteToAttach.getCodigocomite());
                attachedComiteList.add(comiteListComiteToAttach);
            }
            proyecto.setComiteList(attachedComiteList);
            List<Etapa> attachedEtapaList = new ArrayList<Etapa>();
            for (Etapa etapaListEtapaToAttach : proyecto.getEtapaList()) {
                etapaListEtapaToAttach = em.getReference(etapaListEtapaToAttach.getClass(), etapaListEtapaToAttach.getCodigoetapa());
                attachedEtapaList.add(etapaListEtapaToAttach);
            }
            proyecto.setEtapaList(attachedEtapaList);
            List<Rubros> attachedRubrosList = new ArrayList<Rubros>();
            for (Rubros rubrosListRubrosToAttach : proyecto.getRubrosList()) {
                rubrosListRubrosToAttach = em.getReference(rubrosListRubrosToAttach.getClass(), rubrosListRubrosToAttach.getIdrubros());
                attachedRubrosList.add(rubrosListRubrosToAttach);
            }
            proyecto.setRubrosList(attachedRubrosList);
            List<Provedor> attachedProvedorList = new ArrayList<Provedor>();
            for (Provedor provedorListProvedorToAttach : proyecto.getProvedorList()) {
                provedorListProvedorToAttach = em.getReference(provedorListProvedorToAttach.getClass(), provedorListProvedorToAttach.getRut());
                attachedProvedorList.add(provedorListProvedorToAttach);
            }
            proyecto.setProvedorList(attachedProvedorList);
            List<Recursos> attachedRecursosList = new ArrayList<Recursos>();
            for (Recursos recursosListRecursosToAttach : proyecto.getRecursosList()) {
                recursosListRecursosToAttach = em.getReference(recursosListRecursosToAttach.getClass(), recursosListRecursosToAttach.getIdrecurso());
                attachedRecursosList.add(recursosListRecursosToAttach);
            }
            proyecto.setRecursosList(attachedRecursosList);
            List<Convenios> attachedConveniosList = new ArrayList<Convenios>();
            for (Convenios conveniosListConveniosToAttach : proyecto.getConveniosList()) {
                conveniosListConveniosToAttach = em.getReference(conveniosListConveniosToAttach.getClass(), conveniosListConveniosToAttach.getCodigoconvenio());
                attachedConveniosList.add(conveniosListConveniosToAttach);
            }
            proyecto.setConveniosList(attachedConveniosList);
            List<Insumo> attachedInsumoList = new ArrayList<Insumo>();
            for (Insumo insumoListInsumoToAttach : proyecto.getInsumoList()) {
                insumoListInsumoToAttach = em.getReference(insumoListInsumoToAttach.getClass(), insumoListInsumoToAttach.getIdinsumo());
                attachedInsumoList.add(insumoListInsumoToAttach);
            }
            proyecto.setInsumoList(attachedInsumoList);
            em.persist(proyecto);
            for (Unidadorganizacional unidadorganizacionalListUnidadorganizacional : proyecto.getUnidadorganizacionalList()) {
                unidadorganizacionalListUnidadorganizacional.getProyectoList().add(proyecto);
                unidadorganizacionalListUnidadorganizacional = em.merge(unidadorganizacionalListUnidadorganizacional);
            }
            for (Comite comiteListComite : proyecto.getComiteList()) {
                Proyecto oldProyectoOfComiteListComite = comiteListComite.getProyecto();
                comiteListComite.setProyecto(proyecto);
                comiteListComite = em.merge(comiteListComite);
                if (oldProyectoOfComiteListComite != null) {
                    oldProyectoOfComiteListComite.getComiteList().remove(comiteListComite);
                    oldProyectoOfComiteListComite = em.merge(oldProyectoOfComiteListComite);
                }
            }
            for (Etapa etapaListEtapa : proyecto.getEtapaList()) {
                Proyecto oldProyectoOfEtapaListEtapa = etapaListEtapa.getProyecto();
                etapaListEtapa.setProyecto(proyecto);
                etapaListEtapa = em.merge(etapaListEtapa);
                if (oldProyectoOfEtapaListEtapa != null) {
                    oldProyectoOfEtapaListEtapa.getEtapaList().remove(etapaListEtapa);
                    oldProyectoOfEtapaListEtapa = em.merge(oldProyectoOfEtapaListEtapa);
                }
            }
            for (Rubros rubrosListRubros : proyecto.getRubrosList()) {
                Proyecto oldProyectoOfRubrosListRubros = rubrosListRubros.getProyecto();
                rubrosListRubros.setProyecto(proyecto);
                rubrosListRubros = em.merge(rubrosListRubros);
                if (oldProyectoOfRubrosListRubros != null) {
                    oldProyectoOfRubrosListRubros.getRubrosList().remove(rubrosListRubros);
                    oldProyectoOfRubrosListRubros = em.merge(oldProyectoOfRubrosListRubros);
                }
            }
            for (Provedor provedorListProvedor : proyecto.getProvedorList()) {
                Proyecto oldProyectoOfProvedorListProvedor = provedorListProvedor.getProyecto();
                provedorListProvedor.setProyecto(proyecto);
                provedorListProvedor = em.merge(provedorListProvedor);
                if (oldProyectoOfProvedorListProvedor != null) {
                    oldProyectoOfProvedorListProvedor.getProvedorList().remove(provedorListProvedor);
                    oldProyectoOfProvedorListProvedor = em.merge(oldProyectoOfProvedorListProvedor);
                }
            }
            for (Recursos recursosListRecursos : proyecto.getRecursosList()) {
                Proyecto oldProyectoOfRecursosListRecursos = recursosListRecursos.getProyecto();
                recursosListRecursos.setProyecto(proyecto);
                recursosListRecursos = em.merge(recursosListRecursos);
                if (oldProyectoOfRecursosListRecursos != null) {
                    oldProyectoOfRecursosListRecursos.getRecursosList().remove(recursosListRecursos);
                    oldProyectoOfRecursosListRecursos = em.merge(oldProyectoOfRecursosListRecursos);
                }
            }
            for (Convenios conveniosListConvenios : proyecto.getConveniosList()) {
                Proyecto oldProyectoOfConveniosListConvenios = conveniosListConvenios.getProyecto();
                conveniosListConvenios.setProyecto(proyecto);
                conveniosListConvenios = em.merge(conveniosListConvenios);
                if (oldProyectoOfConveniosListConvenios != null) {
                    oldProyectoOfConveniosListConvenios.getConveniosList().remove(conveniosListConvenios);
                    oldProyectoOfConveniosListConvenios = em.merge(oldProyectoOfConveniosListConvenios);
                }
            }
            for (Insumo insumoListInsumo : proyecto.getInsumoList()) {
                Proyecto oldProyectoOfInsumoListInsumo = insumoListInsumo.getProyecto();
                insumoListInsumo.setProyecto(proyecto);
                insumoListInsumo = em.merge(insumoListInsumo);
                if (oldProyectoOfInsumoListInsumo != null) {
                    oldProyectoOfInsumoListInsumo.getInsumoList().remove(insumoListInsumo);
                    oldProyectoOfInsumoListInsumo = em.merge(oldProyectoOfInsumoListInsumo);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findProyecto(proyecto.getCodigocongreso()) != null) {
                throw new PreexistingEntityException("Proyecto " + proyecto + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Proyecto proyecto) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proyecto persistentProyecto = em.find(Proyecto.class, proyecto.getCodigocongreso());
            List<Unidadorganizacional> unidadorganizacionalListOld = persistentProyecto.getUnidadorganizacionalList();
            List<Unidadorganizacional> unidadorganizacionalListNew = proyecto.getUnidadorganizacionalList();
            List<Comite> comiteListOld = persistentProyecto.getComiteList();
            List<Comite> comiteListNew = proyecto.getComiteList();
            List<Etapa> etapaListOld = persistentProyecto.getEtapaList();
            List<Etapa> etapaListNew = proyecto.getEtapaList();
            List<Rubros> rubrosListOld = persistentProyecto.getRubrosList();
            List<Rubros> rubrosListNew = proyecto.getRubrosList();
            List<Provedor> provedorListOld = persistentProyecto.getProvedorList();
            List<Provedor> provedorListNew = proyecto.getProvedorList();
            List<Recursos> recursosListOld = persistentProyecto.getRecursosList();
            List<Recursos> recursosListNew = proyecto.getRecursosList();
            List<Convenios> conveniosListOld = persistentProyecto.getConveniosList();
            List<Convenios> conveniosListNew = proyecto.getConveniosList();
            List<Insumo> insumoListOld = persistentProyecto.getInsumoList();
            List<Insumo> insumoListNew = proyecto.getInsumoList();
            List<String> illegalOrphanMessages = null;
            for (Comite comiteListOldComite : comiteListOld) {
                if (!comiteListNew.contains(comiteListOldComite)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Comite " + comiteListOldComite + " since its proyecto field is not nullable.");
                }
            }
            for (Etapa etapaListOldEtapa : etapaListOld) {
                if (!etapaListNew.contains(etapaListOldEtapa)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Etapa " + etapaListOldEtapa + " since its proyecto field is not nullable.");
                }
            }
            for (Rubros rubrosListOldRubros : rubrosListOld) {
                if (!rubrosListNew.contains(rubrosListOldRubros)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Rubros " + rubrosListOldRubros + " since its proyecto field is not nullable.");
                }
            }
            for (Provedor provedorListOldProvedor : provedorListOld) {
                if (!provedorListNew.contains(provedorListOldProvedor)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Provedor " + provedorListOldProvedor + " since its proyecto field is not nullable.");
                }
            }
            for (Recursos recursosListOldRecursos : recursosListOld) {
                if (!recursosListNew.contains(recursosListOldRecursos)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Recursos " + recursosListOldRecursos + " since its proyecto field is not nullable.");
                }
            }
            for (Convenios conveniosListOldConvenios : conveniosListOld) {
                if (!conveniosListNew.contains(conveniosListOldConvenios)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Convenios " + conveniosListOldConvenios + " since its proyecto field is not nullable.");
                }
            }
            for (Insumo insumoListOldInsumo : insumoListOld) {
                if (!insumoListNew.contains(insumoListOldInsumo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Insumo " + insumoListOldInsumo + " since its proyecto field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            List<Unidadorganizacional> attachedUnidadorganizacionalListNew = new ArrayList<Unidadorganizacional>();
            for (Unidadorganizacional unidadorganizacionalListNewUnidadorganizacionalToAttach : unidadorganizacionalListNew) {
                unidadorganizacionalListNewUnidadorganizacionalToAttach = em.getReference(unidadorganizacionalListNewUnidadorganizacionalToAttach.getClass(), unidadorganizacionalListNewUnidadorganizacionalToAttach.getCodigounidad());
                attachedUnidadorganizacionalListNew.add(unidadorganizacionalListNewUnidadorganizacionalToAttach);
            }
            unidadorganizacionalListNew = attachedUnidadorganizacionalListNew;
            proyecto.setUnidadorganizacionalList(unidadorganizacionalListNew);
            List<Comite> attachedComiteListNew = new ArrayList<Comite>();
            for (Comite comiteListNewComiteToAttach : comiteListNew) {
                comiteListNewComiteToAttach = em.getReference(comiteListNewComiteToAttach.getClass(), comiteListNewComiteToAttach.getCodigocomite());
                attachedComiteListNew.add(comiteListNewComiteToAttach);
            }
            comiteListNew = attachedComiteListNew;
            proyecto.setComiteList(comiteListNew);
            List<Etapa> attachedEtapaListNew = new ArrayList<Etapa>();
            for (Etapa etapaListNewEtapaToAttach : etapaListNew) {
                etapaListNewEtapaToAttach = em.getReference(etapaListNewEtapaToAttach.getClass(), etapaListNewEtapaToAttach.getCodigoetapa());
                attachedEtapaListNew.add(etapaListNewEtapaToAttach);
            }
            etapaListNew = attachedEtapaListNew;
            proyecto.setEtapaList(etapaListNew);
            List<Rubros> attachedRubrosListNew = new ArrayList<Rubros>();
            for (Rubros rubrosListNewRubrosToAttach : rubrosListNew) {
                rubrosListNewRubrosToAttach = em.getReference(rubrosListNewRubrosToAttach.getClass(), rubrosListNewRubrosToAttach.getIdrubros());
                attachedRubrosListNew.add(rubrosListNewRubrosToAttach);
            }
            rubrosListNew = attachedRubrosListNew;
            proyecto.setRubrosList(rubrosListNew);
            List<Provedor> attachedProvedorListNew = new ArrayList<Provedor>();
            for (Provedor provedorListNewProvedorToAttach : provedorListNew) {
                provedorListNewProvedorToAttach = em.getReference(provedorListNewProvedorToAttach.getClass(), provedorListNewProvedorToAttach.getRut());
                attachedProvedorListNew.add(provedorListNewProvedorToAttach);
            }
            provedorListNew = attachedProvedorListNew;
            proyecto.setProvedorList(provedorListNew);
            List<Recursos> attachedRecursosListNew = new ArrayList<Recursos>();
            for (Recursos recursosListNewRecursosToAttach : recursosListNew) {
                recursosListNewRecursosToAttach = em.getReference(recursosListNewRecursosToAttach.getClass(), recursosListNewRecursosToAttach.getIdrecurso());
                attachedRecursosListNew.add(recursosListNewRecursosToAttach);
            }
            recursosListNew = attachedRecursosListNew;
            proyecto.setRecursosList(recursosListNew);
            List<Convenios> attachedConveniosListNew = new ArrayList<Convenios>();
            for (Convenios conveniosListNewConveniosToAttach : conveniosListNew) {
                conveniosListNewConveniosToAttach = em.getReference(conveniosListNewConveniosToAttach.getClass(), conveniosListNewConveniosToAttach.getCodigoconvenio());
                attachedConveniosListNew.add(conveniosListNewConveniosToAttach);
            }
            conveniosListNew = attachedConveniosListNew;
            proyecto.setConveniosList(conveniosListNew);
            List<Insumo> attachedInsumoListNew = new ArrayList<Insumo>();
            for (Insumo insumoListNewInsumoToAttach : insumoListNew) {
                insumoListNewInsumoToAttach = em.getReference(insumoListNewInsumoToAttach.getClass(), insumoListNewInsumoToAttach.getIdinsumo());
                attachedInsumoListNew.add(insumoListNewInsumoToAttach);
            }
            insumoListNew = attachedInsumoListNew;
            proyecto.setInsumoList(insumoListNew);
            proyecto = em.merge(proyecto);
            for (Unidadorganizacional unidadorganizacionalListOldUnidadorganizacional : unidadorganizacionalListOld) {
                if (!unidadorganizacionalListNew.contains(unidadorganizacionalListOldUnidadorganizacional)) {
                    unidadorganizacionalListOldUnidadorganizacional.getProyectoList().remove(proyecto);
                    unidadorganizacionalListOldUnidadorganizacional = em.merge(unidadorganizacionalListOldUnidadorganizacional);
                }
            }
            for (Unidadorganizacional unidadorganizacionalListNewUnidadorganizacional : unidadorganizacionalListNew) {
                if (!unidadorganizacionalListOld.contains(unidadorganizacionalListNewUnidadorganizacional)) {
                    unidadorganizacionalListNewUnidadorganizacional.getProyectoList().add(proyecto);
                    unidadorganizacionalListNewUnidadorganizacional = em.merge(unidadorganizacionalListNewUnidadorganizacional);
                }
            }
            for (Comite comiteListNewComite : comiteListNew) {
                if (!comiteListOld.contains(comiteListNewComite)) {
                    Proyecto oldProyectoOfComiteListNewComite = comiteListNewComite.getProyecto();
                    comiteListNewComite.setProyecto(proyecto);
                    comiteListNewComite = em.merge(comiteListNewComite);
                    if (oldProyectoOfComiteListNewComite != null && !oldProyectoOfComiteListNewComite.equals(proyecto)) {
                        oldProyectoOfComiteListNewComite.getComiteList().remove(comiteListNewComite);
                        oldProyectoOfComiteListNewComite = em.merge(oldProyectoOfComiteListNewComite);
                    }
                }
            }
            for (Etapa etapaListNewEtapa : etapaListNew) {
                if (!etapaListOld.contains(etapaListNewEtapa)) {
                    Proyecto oldProyectoOfEtapaListNewEtapa = etapaListNewEtapa.getProyecto();
                    etapaListNewEtapa.setProyecto(proyecto);
                    etapaListNewEtapa = em.merge(etapaListNewEtapa);
                    if (oldProyectoOfEtapaListNewEtapa != null && !oldProyectoOfEtapaListNewEtapa.equals(proyecto)) {
                        oldProyectoOfEtapaListNewEtapa.getEtapaList().remove(etapaListNewEtapa);
                        oldProyectoOfEtapaListNewEtapa = em.merge(oldProyectoOfEtapaListNewEtapa);
                    }
                }
            }
            for (Rubros rubrosListNewRubros : rubrosListNew) {
                if (!rubrosListOld.contains(rubrosListNewRubros)) {
                    Proyecto oldProyectoOfRubrosListNewRubros = rubrosListNewRubros.getProyecto();
                    rubrosListNewRubros.setProyecto(proyecto);
                    rubrosListNewRubros = em.merge(rubrosListNewRubros);
                    if (oldProyectoOfRubrosListNewRubros != null && !oldProyectoOfRubrosListNewRubros.equals(proyecto)) {
                        oldProyectoOfRubrosListNewRubros.getRubrosList().remove(rubrosListNewRubros);
                        oldProyectoOfRubrosListNewRubros = em.merge(oldProyectoOfRubrosListNewRubros);
                    }
                }
            }
            for (Provedor provedorListNewProvedor : provedorListNew) {
                if (!provedorListOld.contains(provedorListNewProvedor)) {
                    Proyecto oldProyectoOfProvedorListNewProvedor = provedorListNewProvedor.getProyecto();
                    provedorListNewProvedor.setProyecto(proyecto);
                    provedorListNewProvedor = em.merge(provedorListNewProvedor);
                    if (oldProyectoOfProvedorListNewProvedor != null && !oldProyectoOfProvedorListNewProvedor.equals(proyecto)) {
                        oldProyectoOfProvedorListNewProvedor.getProvedorList().remove(provedorListNewProvedor);
                        oldProyectoOfProvedorListNewProvedor = em.merge(oldProyectoOfProvedorListNewProvedor);
                    }
                }
            }
            for (Recursos recursosListNewRecursos : recursosListNew) {
                if (!recursosListOld.contains(recursosListNewRecursos)) {
                    Proyecto oldProyectoOfRecursosListNewRecursos = recursosListNewRecursos.getProyecto();
                    recursosListNewRecursos.setProyecto(proyecto);
                    recursosListNewRecursos = em.merge(recursosListNewRecursos);
                    if (oldProyectoOfRecursosListNewRecursos != null && !oldProyectoOfRecursosListNewRecursos.equals(proyecto)) {
                        oldProyectoOfRecursosListNewRecursos.getRecursosList().remove(recursosListNewRecursos);
                        oldProyectoOfRecursosListNewRecursos = em.merge(oldProyectoOfRecursosListNewRecursos);
                    }
                }
            }
            for (Convenios conveniosListNewConvenios : conveniosListNew) {
                if (!conveniosListOld.contains(conveniosListNewConvenios)) {
                    Proyecto oldProyectoOfConveniosListNewConvenios = conveniosListNewConvenios.getProyecto();
                    conveniosListNewConvenios.setProyecto(proyecto);
                    conveniosListNewConvenios = em.merge(conveniosListNewConvenios);
                    if (oldProyectoOfConveniosListNewConvenios != null && !oldProyectoOfConveniosListNewConvenios.equals(proyecto)) {
                        oldProyectoOfConveniosListNewConvenios.getConveniosList().remove(conveniosListNewConvenios);
                        oldProyectoOfConveniosListNewConvenios = em.merge(oldProyectoOfConveniosListNewConvenios);
                    }
                }
            }
            for (Insumo insumoListNewInsumo : insumoListNew) {
                if (!insumoListOld.contains(insumoListNewInsumo)) {
                    Proyecto oldProyectoOfInsumoListNewInsumo = insumoListNewInsumo.getProyecto();
                    insumoListNewInsumo.setProyecto(proyecto);
                    insumoListNewInsumo = em.merge(insumoListNewInsumo);
                    if (oldProyectoOfInsumoListNewInsumo != null && !oldProyectoOfInsumoListNewInsumo.equals(proyecto)) {
                        oldProyectoOfInsumoListNewInsumo.getInsumoList().remove(insumoListNewInsumo);
                        oldProyectoOfInsumoListNewInsumo = em.merge(oldProyectoOfInsumoListNewInsumo);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = proyecto.getCodigocongreso();
                if (findProyecto(id) == null) {
                    throw new NonexistentEntityException("The proyecto with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proyecto proyecto;
            try {
                proyecto = em.getReference(Proyecto.class, id);
                proyecto.getCodigocongreso();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The proyecto with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Comite> comiteListOrphanCheck = proyecto.getComiteList();
            for (Comite comiteListOrphanCheckComite : comiteListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Comite " + comiteListOrphanCheckComite + " in its comiteList field has a non-nullable proyecto field.");
            }
            List<Etapa> etapaListOrphanCheck = proyecto.getEtapaList();
            for (Etapa etapaListOrphanCheckEtapa : etapaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Etapa " + etapaListOrphanCheckEtapa + " in its etapaList field has a non-nullable proyecto field.");
            }
            List<Rubros> rubrosListOrphanCheck = proyecto.getRubrosList();
            for (Rubros rubrosListOrphanCheckRubros : rubrosListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Rubros " + rubrosListOrphanCheckRubros + " in its rubrosList field has a non-nullable proyecto field.");
            }
            List<Provedor> provedorListOrphanCheck = proyecto.getProvedorList();
            for (Provedor provedorListOrphanCheckProvedor : provedorListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Provedor " + provedorListOrphanCheckProvedor + " in its provedorList field has a non-nullable proyecto field.");
            }
            List<Recursos> recursosListOrphanCheck = proyecto.getRecursosList();
            for (Recursos recursosListOrphanCheckRecursos : recursosListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Recursos " + recursosListOrphanCheckRecursos + " in its recursosList field has a non-nullable proyecto field.");
            }
            List<Convenios> conveniosListOrphanCheck = proyecto.getConveniosList();
            for (Convenios conveniosListOrphanCheckConvenios : conveniosListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Convenios " + conveniosListOrphanCheckConvenios + " in its conveniosList field has a non-nullable proyecto field.");
            }
            List<Insumo> insumoListOrphanCheck = proyecto.getInsumoList();
            for (Insumo insumoListOrphanCheckInsumo : insumoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proyecto (" + proyecto + ") cannot be destroyed since the Insumo " + insumoListOrphanCheckInsumo + " in its insumoList field has a non-nullable proyecto field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            List<Unidadorganizacional> unidadorganizacionalList = proyecto.getUnidadorganizacionalList();
            for (Unidadorganizacional unidadorganizacionalListUnidadorganizacional : unidadorganizacionalList) {
                unidadorganizacionalListUnidadorganizacional.getProyectoList().remove(proyecto);
                unidadorganizacionalListUnidadorganizacional = em.merge(unidadorganizacionalListUnidadorganizacional);
            }
            em.remove(proyecto);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Proyecto> findProyectoEntities() {
        return findProyectoEntities(true, -1, -1);
    }

    public List<Proyecto> findProyectoEntities(int maxResults, int firstResult) {
        return findProyectoEntities(false, maxResults, firstResult);
    }

    private List<Proyecto> findProyectoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Proyecto.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Proyecto findProyecto(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Proyecto.class, id);
        } finally {
            em.close();
        }
    }

    public int getProyectoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Proyecto> rt = cq.from(Proyecto.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
